/**
 * 完整提取并合并产品所有信息（不遗漏任何字段）
 * @param {Array} data - 原始响应中的data数组
 * @param {Number} productType - 产品类型：1-泛营地接待, 2-综合研学业务, 3-目的地接待, 4-组团业务, 5-研学活动
 * @returns {Array} 完全合并后的产品数组
 */
export function mergeAllProducts(data, productType) {
    return data.map((item, index) => {
        console.log('🔍 mergeAllProducts - item:', item);
        const {
            p1,
            p2,
            p3,
            totalPrice,
            productPeriodCallRelation,
            merchantName,
            saleArea,
            shopName,
            branchName
        } = item;

        // 1. 根据 productType 确定主信息源和价格结构
        let mainSource, mainData;

        // 获取产品的实际 productType（如果传入的是undefined，则从数据中读取）
        const actualProductType = productType || p3?.productSpu?.productType || p2?.productSpu?.productType || p1?.productSpu?.productType;

        console.log('🔍 mergeAllProducts - productType:', actualProductType, 'p1:', !!p1, 'p2:', !!p2, 'p3:', !!p3);

        if (actualProductType == 1 || actualProductType == 3) {
            // productType=1（泛营地接待-B1创）和 productType=3（目的地接待-B2创）使用 p1 数据
            mainSource = "p1";
            mainData = p1;
        } else if (actualProductType == 2 || actualProductType == 4) {
            // productType=2（综合研学业务-B2创）和 productType=4（组团业务-B2调B1）使用 p2 数据
            mainSource = "p2";
            mainData = p2;
        } else if (actualProductType == 5) {
            // productType=5（研学活动-B3调B2）使用 p3 数据
            mainSource = "p3";
            mainData = p3;
        } else {
            // 未指定productType时，使用旧逻辑兼容（优先级：p3 > p2 > p1）
            console.warn('⚠️ 未指定productType，使用默认逻辑');
            if (p3 != null) {
                mainSource = "p3";
                mainData = p3;
            } else if (p2 != null) {
                mainSource = "p2";
                mainData = p2;
            } else if (p1 != null) {
                mainSource = "p1";
                mainData = p1;
            } else {
                return {
                    index: index + 1,
                    status: "invalid",
                    message: "无有效产品数据",
                };
            }
        }

        // 🔑 安全检查：如果根据 productType 选择的数据源是 null，使用兜底逻辑
        if (mainData == null) {
            console.warn('⚠️ 根据productType选择的数据源为null，使用兜底逻辑', {
                productType: actualProductType,
                mainSource,
                p1: !!p1,
                p2: !!p2,
                p3: !!p3
            });

            if (p3 != null) {
                mainSource = "p3";
                mainData = p3;
            } else if (p2 != null) {
                mainSource = "p2";
                mainData = p2;
            } else if (p1 != null) {
                mainSource = "p1";
                mainData = p1;
            } else {
                return {
                    index: index + 1,
                    status: "invalid",
                    message: "无有效产品数据",
                };
            }
        }

        // 2. 完整提取主信息（保留所有原始字段）
        const mainInfo = {
            source: mainSource,
            productSpu: mainData.productSpu || {}, // 完整保留spu所有字段
            productSku: mainData.productSku || {}, // 完整保留sku所有字段
            price: totalPrice || null,
            sourceType: mainSource,
            merchantName: merchantName || "",
            saleArea: saleArea || "",
            shopName: shopName || "",
            branchName: branchName || "",
        };

        // 3. 完整提取辅助信息（所有非主信息源的p，保留全部字段）
        const auxiliaryInfo = [];
        const addAuxiliary = (data, source) => {
            if (!data || source === mainSource) return;
            auxiliaryInfo.push({
                source,
                productSpu: data.productSpu || {}, // 完整保留spu
                productSku: data.productSku || {}, // 完整保留sku
                sourceType: source,
            });
        };
        addAuxiliary(p1, "p1");
        addAuxiliary(p2, "p2");
        addAuxiliary(p3, "p3");

        // 4. 合并specificItinerary（按day分组，保留所有细节）
        const mergedItineraries = mergeItineraries(p1, p2, p3);

        // 5. 合并其他数组字段（如productFeatures、expenses等，按来源区分）
        const mergedFeatures = mergeArrayFields(p1, p2, p3, "productFeatures");
        const mergedIncludedExpenses = mergeArrayFields(
            p1,
            p2,
            p3,
            "expensesIncluded"
        );
        // 注意：otherExpenses已改为字符串类型，不再需要合并
        // 直接从主数据源获取
        const otherExpenses = mainData?.productSku?.otherExpenses || '';

        // 6. 整合所有信息为一个对象
        return {
            index: index + 1,
            mainInfo, // 主信息（完整）
            auxiliaryInfo: auxiliaryInfo.length > 0 ? auxiliaryInfo : null, // 辅助信息（完整）
            mergedItineraries, // 合并后的行程
            mergedFeatures, // 合并后的产品特色
            mergedIncludedExpenses, // 合并后的包含费用
            otherExpenses, // 其他费用（字符串类型，不合并）
            // 保留原始所有p的引用（如需追溯）
            productPeriodCallRelation,
            originalPs: {
                p1,
                p2,
                p3,
            },
        };
    });
}

/**
 * 合并specificItinerary，按day分组（保留所有字段）
 */
function mergeItineraries(p1, p2, p3) {
    const allItineraries = [];
    // 收集所有行程并标记来源
    const collectItinerary = (data, source) => {
        if (!(data && data.productSku && data.productSku.specificItinerary)) return; // 修复此行
        data.productSku.specificItinerary.forEach((item) => {
            allItineraries.push({
                ...item,
                source,
            });
        });
    };
    collectItinerary(p1, "p1");
    collectItinerary(p2, "p2");
    collectItinerary(p3, "p3");

    // 按day分组（保留所有字段）
    const dayGroups = {};
    allItineraries.forEach((item) => {
        const day = item.day || "未知天数";
        if (!dayGroups[day]) {
            dayGroups[day] = {
                day,
                main: item.main || "", // day相同main相同，取首次值
                details: [], // 存放该day的所有行程细节（含所有原始字段）
            };
        }
        dayGroups[day].details.push({
            ...item,
        }); // 完整保留所有字段
    });

    // 转换为数组并排序
    const result = [];
    for (const key in dayGroups) {
        result.push(dayGroups[key]);
    }
    return result.sort((a, b) => a.day - b.day || a.day.localeCompare(b.day));
}

/**
 * 合并数组类型字段（如productFeatures、expensesIncluded等）
 * 注意：某些字段（如otherExpenses、expensesExcluded）已改为字符串类型
 * @param {Object} p1-p3 - 产品数据
 * @param {string} field - 要合并的字段名（如'productFeatures'）
 * @returns {Array} 合并后的数组（带来源标识）
 */
function mergeArrayFields(p1, p2, p3, field) {
    const merged = [];
    // 收集所有p中的目标字段并标记来源
    const collect = (data, source) => {
        const sku = data && data.productSku;
        if (!sku || !sku[field]) return;

        // 检查字段类型
        const fieldValue = sku[field];

        // 如果是字符串类型（如otherExpenses、expensesExcluded、customizationPrompt），跳过处理
        if (typeof fieldValue === 'string') {
            // 不合并字符串类型的字段，返回空数组
            return;
        }

        // 如果是数组类型，则正常合并
        if (Array.isArray(fieldValue)) {
            fieldValue.forEach((item) => {
                merged.push({
                    ...item,
                    source,
                });
            });
        }
    };
    collect(p1, "p1");
    collect(p2, "p2");
    collect(p3, "p3");
    return merged;
}

// 如果需要单独导出内部函数，也可以添加下面的导出语句
export { mergeItineraries, mergeArrayFields };